{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个实例中，我们使用tensorflow来实现一个简单的手写数字识别的网络，并用这个网络来做个\n",
    "简单的识别示例。\n",
    "\n",
    "首先导入一些用到的库。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:50.515650Z",
     "start_time": "2018-06-01T06:32:43.133728Z"
    }
   },
   "outputs": [],
   "source": [
    "#导入库\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data #自动下载数据\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T05:39:48.304594Z",
     "start_time": "2018-06-01T04:55:17.674707Z"
    }
   },
   "source": [
    "先来看看数据长什么样子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.075054Z",
     "start_time": "2018-06-01T06:32:50.518290Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0915 13:35:23.147282  2988 deprecation.py:323] From <ipython-input-2-c46f6362250a>:1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "W0915 13:35:23.152267  2988 deprecation.py:323] From c:\\python\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "W0915 13:35:23.153264  2988 deprecation.py:323] From c:\\python\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0915 13:35:23.704439  2988 deprecation.py:323] From c:\\python\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "W0915 13:35:23.719390  2988 deprecation.py:323] From c:\\python\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "W0915 13:35:23.856018  2988 deprecation.py:323] From c:\\python\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "(55000, 784)\n",
      "(55000, 10)\n",
      "(5000, 784)\n",
      "(5000, 10)\n",
      "(10000, 784)\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets(\"./\", one_hot=True) #当前目录找 用onehot找\n",
    "\n",
    "print(mnist.train.images.shape)  #训练集 验证集 测试集\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T05:49:40.128071Z",
     "start_time": "2018-06-01T05:49:40.123888Z"
    }
   },
   "source": [
    "train集 55000x784,mnist是28x28单通道图像，valida 5000张图片，test--10000\n",
    "可以看到images里面有数量不等的图片，每张图片是28x28长度的一个一维向量，\n",
    "所以用的时候需要先给它还原成28x28的二维图片。labels中则是图片对应的数字的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.695746Z",
     "start_time": "2018-06-01T06:32:51.077167Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4, 4, idx + 1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(np.argmax(mnist.train.labels[idx])))#le'vel是onehot-->argmax\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28, 28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，定义用于训练的网络，首先定义网络的输入。\n",
    "\n",
    "这里我们直接使用上面的数据作为输入，所以定义两个placeholder分别用于图像和lable数据，另外，定义一个bool类型的变量用于标识当前网络是否正在训练。\n",
    "\n",
    "为了让网络更高效的运行，多个数据会被组织成一个batch送入网络，两个placeholder的第一个维度就是batchsize，因为我们这里还没有确定batchsize，所以第一个维度留空。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.706044Z",
     "start_time": "2018-06-01T06:32:51.698913Z"
    }
   },
   "outputs": [],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784], name='x') #placeholder--网络输入的图片 none--batchsize的大小是空的\n",
    "y = tf.placeholder(\"float\", [None, 10], name='y')   # 图片对应的level"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为我们输入的是图片展开后的一维向量，所以第一步就需要先把一维向量还原为二维的图片。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.719298Z",
     "start_time": "2018-06-01T06:32:51.707730Z"
    }
   },
   "outputs": [],
   "source": [
    "x_image = tf.reshape(x, [-1, 28, 28, 1]) #二维数据还原（图片） batchsize -1--自动计算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 网络结构的定义"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:07:36.530623Z",
     "start_time": "2018-06-01T06:07:36.522665Z"
    }
   },
   "source": [
    "接下来，我们定义第一个卷积层，使用6个5X5的卷积核对输入数据进行卷积，\n",
    "padding方式选择valid，所以输出数据的宽高变为24x24,但是深度已经从原来的1变成了6。\n",
    "本层卷积的激活函数为relu。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.764292Z",
     "start_time": "2018-06-01T06:32:51.721295Z"
    }
   },
   "outputs": [],
   "source": [
    "#定义卷积\n",
    "with tf.name_scope('conv1'):\n",
    "    C1 = tf.contrib.slim.conv2d(\n",
    "        x_image, 6, [5, 5], padding='VALID', activation_fn=tf.nn.relu)\n",
    "    #6个卷积核5x5, relu激活"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来进行stride为2的最大池化，池化后，输出深度channel不变，但是长宽减半，所以输出变成了12x12,深度6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.774112Z",
     "start_time": "2018-06-01T06:32:51.766784Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('pool1'):\n",
    "    S2 = tf.contrib.slim.max_pool2d(C1, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:10:16.678485Z",
     "start_time": "2018-06-01T06:10:16.671472Z"
    }
   },
   "source": [
    "接下来，我们定义第二个卷积层，使用16个5X5的卷积核对输入数据进行卷积，\n",
    "padding方式还是选择valid，输出8x8,深度为16，本层卷积的激活函数为relu。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.805912Z",
     "start_time": "2018-06-01T06:32:51.776959Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('conv2'):\n",
    "    C3 = tf.contrib.slim.conv2d(\n",
    "        S2, 16, [5, 5], padding='VALID', activation_fn=tf.nn.relu)\n",
    "    #卷积核个数为16--输出8x8，深度为16"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再进行一次stride为2的最大池化，输出为4x4,深度16。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.814748Z",
     "start_time": "2018-06-01T06:32:51.807560Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('pool2'): #最大池化\n",
    "    S4 = tf.contrib.slim.max_pool2d(C3, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 输入到全连接full connection -接入的数据是一维的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "池化后的数据是3维的，这里做一个拉平的操作，将3维数据展开到1维，然后送入两层全连接，全连接隐层中神经元个数分别为120，84。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.856740Z",
     "start_time": "2018-06-01T06:32:51.817287Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0915 13:50:57.879133  2988 deprecation.py:323] From c:\\python\\lib\\site-packages\\tensorflow\\contrib\\layers\\python\\layers\\layers.py:1634: flatten (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.flatten instead.\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('fc1'):\n",
    "    S4_flat = tf.contrib.slim.flatten(S4)\n",
    "    C5 = tf.contrib.slim.fully_connected(\n",
    "        S4_flat, 120, activation_fn=tf.nn.relu)  #120个隐层\n",
    "\n",
    "with tf.name_scope('fc2'):\n",
    "    F6 = tf.contrib.slim.fully_connected(C5, 84, activation_fn=tf.nn.relu) \n",
    "    #84个隐层\n",
    "    #最终的特征--对特征采用dropout"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 分类器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:17:39.880958Z",
     "start_time": "2018-06-01T06:17:39.869797Z"
    }
   },
   "source": [
    "###### 对特征添加一个0.6的dropout，以40%的概率丢弃特征中的某些数据，\n",
    "这样可以提高网络的推广能力，减少过拟合的可能性。\n",
    "\n",
    "需要注意的是，dropout仅在训练的时候使用，验证的时候，需要关闭dropout，\n",
    "所以验证时候的keep_prob是1.0。\n",
    "\n",
    "dropout的输出最终送入一个隐层为10的全连接层，这个全连接层即为最后的分类器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.913419Z",
     "start_time": "2018-06-01T06:32:51.860766Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0915 13:56:47.830945  2988 deprecation.py:506] From <ipython-input-15-df8693216e17>:4: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('dropout'):\n",
    "    keep_prob = tf.placeholder(name='keep_prob', dtype=tf.float32)\n",
    "    #定义placeholder--定义为keep_prob\n",
    "    F6_drop = tf.nn.dropout(F6, keep_prob)#特征实施，\n",
    "    #p=0,6,以40%的概率丢弃特征中的某些数据。\n",
    "\n",
    "with tf.name_scope('fc3'):\n",
    "    logits = tf.contrib.slim.fully_connected(F6_drop, 10, activation_fn=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来定义loss和用于优化网络的优化器。loss计算使用了sparse_softmax_cross_entropy_with_logits,\n",
    "这样做的好处是labels可以不用手动做one_hot省了一些麻烦。这里使用了sgd优化器，学习率为0.3。\n",
    "\n",
    ">试试看，增大减小学习率，换个优化器再进行训练会发生什么。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:52.084738Z",
     "start_time": "2018-06-01T06:32:51.915376Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0915 13:59:40.449437  2988 deprecation.py:323] From <ipython-input-16-c403ed9e48f4>:3: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n",
      "\n",
      "I0915 13:59:40.585074  2988 summary_op_util.py:66] Summary name Conv/weights:0 is illegal; using Conv/weights_0 instead.\n",
      "I0915 13:59:40.591058  2988 summary_op_util.py:66] Summary name Conv/biases:0 is illegal; using Conv/biases_0 instead.\n",
      "I0915 13:59:40.595048  2988 summary_op_util.py:66] Summary name Conv_1/weights:0 is illegal; using Conv_1/weights_0 instead.\n",
      "I0915 13:59:40.603025  2988 summary_op_util.py:66] Summary name Conv_1/biases:0 is illegal; using Conv_1/biases_0 instead.\n",
      "I0915 13:59:40.607527  2988 summary_op_util.py:66] Summary name Conv_2/weights:0 is illegal; using Conv_2/weights_0 instead.\n",
      "I0915 13:59:40.615506  2988 summary_op_util.py:66] Summary name Conv_2/biases:0 is illegal; using Conv_2/biases_0 instead.\n",
      "I0915 13:59:40.619497  2988 summary_op_util.py:66] Summary name fully_connected/weights:0 is illegal; using fully_connected/weights_0 instead.\n",
      "I0915 13:59:40.623484  2988 summary_op_util.py:66] Summary name fully_connected/biases:0 is illegal; using fully_connected/biases_0 instead.\n",
      "I0915 13:59:40.629468  2988 summary_op_util.py:66] Summary name fully_connected_1/weights:0 is illegal; using fully_connected_1/weights_0 instead.\n",
      "I0915 13:59:40.634464  2988 summary_op_util.py:66] Summary name fully_connected_1/biases:0 is illegal; using fully_connected_1/biases_0 instead.\n",
      "I0915 13:59:40.639441  2988 summary_op_util.py:66] Summary name fully_connected_2/weights:0 is illegal; using fully_connected_2/weights_0 instead.\n",
      "I0915 13:59:40.645426  2988 summary_op_util.py:66] Summary name fully_connected_2/biases:0 is illegal; using fully_connected_2/biases_0 instead.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conv/weights:0\n",
      "Conv/biases:0\n",
      "Conv_1/weights:0\n",
      "Conv_1/biases:0\n",
      "Conv_2/weights:0\n",
      "Conv_2/biases:0\n",
      "fully_connected/weights:0\n",
      "fully_connected/biases:0\n",
      "fully_connected_1/weights:0\n",
      "fully_connected_1/biases:0\n",
      "fully_connected_2/weights:0\n",
      "fully_connected_2/biases:0\n"
     ]
    }
   ],
   "source": [
    "#定义loss函数，交叉熵损失\n",
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "#为经激活的输出与Labels  是softmax\n",
    "\n",
    "l2_loss = tf.add_n([\n",
    "    tf.nn.l2_loss(w)  #正则化 L2,取权重\n",
    "    for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n",
    "])   #正则化 L2, 再加和\n",
    "\n",
    "for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES):\n",
    "    print(w.name)\n",
    "    tf.summary.histogram(w.name, w) #记录权重， 应用在矩阵\n",
    "    \n",
    "total_loss = cross_entropy_loss + 7e-5 * l2_loss  #交叉熵损失与L2损失 之和，L2损失权重7e-5\n",
    "tf.summary.scalar('cross_entropy_loss', cross_entropy_loss)\n",
    "tf.summary.scalar('l2_loss', l2_loss)  #应用单个的数值\n",
    "tf.summary.scalar('total_loss', total_loss)\n",
    "\n",
    "optimizer = tf.train.GradientDescentOptimizer(\n",
    "    learning_rate=0.3).minimize(total_loss)\n",
    "# optimizar优化total loss 梯度下降优化器    学习率0.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:25:56.449132Z",
     "start_time": "2018-06-01T06:25:56.438340Z"
    }
   },
   "source": [
    "需要注意的是，上面的网络，最后输出的是未经softmax的原始logits，而不是概率分布，\n",
    "要想看到概率分布，还需要做一下softmax。\n",
    "\n",
    "将输出的结果与正确结果进行对比，即可得到我们的网络输出结果的准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:39:50.010829Z",
     "start_time": "2018-06-01T06:39:49.997501Z"
    }
   },
   "outputs": [],
   "source": [
    "pred = tf.nn.softmax(logits)  #概率\n",
    "correct_pred = tf.equal(tf.argmax(y, 1), tf.argmax(logits, 1)) \n",
    "#argmax核Labels比对，相等则正确/\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "saver用于保存或恢复训练的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:52.127795Z",
     "start_time": "2018-06-01T06:32:52.103115Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "trainig_step = 1100\n",
    "#55000*2=100*1100  训练数据跑了两遍===2个 epoch\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上定义的所有操作，均为计算图，也就是仅仅是定义了网络的结构，实际需要运行的话，还需要创建一个session，并将数据填入网络中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:35:22.270272Z",
     "start_time": "2018-06-01T06:33:18.829198Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.306454, the validation accuracy is 0.9366\n",
      "after 200 training steps, the loss is 0.239449, the validation accuracy is 0.9524\n",
      "after 300 training steps, the loss is 0.633097, the validation accuracy is 0.9402\n",
      "after 400 training steps, the loss is 0.0820813, the validation accuracy is 0.9714\n",
      "after 500 training steps, the loss is 0.111278, the validation accuracy is 0.9748\n",
      "after 600 training steps, the loss is 0.10579, the validation accuracy is 0.977\n",
      "after 700 training steps, the loss is 0.0148056, the validation accuracy is 0.9804\n",
      "after 800 training steps, the loss is 0.070492, the validation accuracy is 0.9822\n",
      "after 900 training steps, the loss is 0.201729, the validation accuracy is 0.9736\n",
      "after 1000 training steps, the loss is 0.124317, the validation accuracy is 0.977\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.983\n"
     ]
    }
   ],
   "source": [
    "merged = tf.summary.merge_all()   #搜集定义的summary \n",
    "with tf.Session() as sess:  #\n",
    "\n",
    "    writer = tf.summary.FileWriter(\"logs/\", sess.graph)  #以一个文件的形式\n",
    "\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "        keep_prob: 1.0    #验证的时候为1\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels, keep_prob: 1.0}\n",
    "\n",
    "    #训练过程\n",
    "    for i in range(trainig_step):\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss, rs = sess.run(\n",
    "            [optimizer, cross_entropy_loss, merged],  #merge--参数写道磁盘上 summary\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                keep_prob: 0.6\n",
    "            })\n",
    "        writer.add_summary(rs, i)\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率   验证集上\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)  #保存形式 自动加编号\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:58:16.766415Z",
     "start_time": "2018-06-01T06:58:15.918700Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I0915 14:33:41.352908  2988 saver.py:1280] Restoring parameters from ./model.ckpt-1000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:    # 新建了一个tensorflow的核心\n",
    "    ckpt = tf.train.get_checkpoint_state('./')  #获得checkpoint信息\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)  #restore目录\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16],\n",
    "                keep_prob: 1.0\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(\n",
    "                np.argmax(mnist.test.labels[idx]), order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "checkpoint1000 加载，因为size小8，一共16张图片，最后的准确率为1 表示都分对了，\n",
    "label-7，预测值也是7，置信区间为100%，在label为5时，置信度为57%，基本上都预测成功了"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
